/**
 * @file gameservice.cpp
 * @brief 游戏服务类实现文件
 *
 * 实现游戏服务的所有业务逻辑，包括：
 * - 游戏服务器列表的获取和解析
 * - 游戏会话的创建和管理
 * - JSON数据的解析和结构体转换
 * - 服务器筛选和排序功能
 * - 最佳服务器推荐算法
 */

#include "../include/gameservice.h"
#include "../include/config.h"
#include <QJsonDocument>    // JSON文档处理
#include <QDebug>           // 调试输出

/**
 * @brief GameService构造函数（创建独立的ApiClient）
 * @param parent 父对象指针
 *
 * 初始化游戏服务的所有组件：
 * 1. 创建API客户端并设置基础URL
 * 2. 创建服务发现客户端
 * 3. 建立信号槽连接处理API响应
 */
GameService::GameService(QObject *parent)
    : QObject(parent)
    , m_apiClient(new ApiClient(Config::getApiBaseUrl(), this))  // 创建API客户端
    , m_serviceDiscovery(new GameServiceDiscovery(Config::getApiBaseUrl(), this))  // 创建服务发现客户端
{
    // === 建立传统API信号槽连接 ===
    connect(m_apiClient, &ApiClient::requestFinished,
            this, &GameService::onApiResponse);
    
    // === 建立服务发现信号槽连接 ===
    connect(m_serviceDiscovery, &GameServiceDiscovery::servicesReceived,
            this, &GameService::onServicesDiscovered);
    connect(m_serviceDiscovery, &GameServiceDiscovery::errorOccurred,
            this, &GameService::onServiceDiscoveryError);
    connect(m_serviceDiscovery, &GameServiceDiscovery::networkError,
            this, [this](const QString &error) {
                emit serviceDiscoveryError(error, "NETWORK_ERROR");
            });
}

/**
 * @brief GameService构造函数（使用共享的ApiClient）
 * @param apiClient 共享的API客户端实例（通常来自AuthService）
 * @param parent 父对象指针
 *
 * 使用已存在的ApiClient实例，这样可以共享认证令牌：
 * 1. 使用传入的API客户端实例
 * 2. 创建服务发现客户端
 * 3. 建立信号槽连接处理API响应
 * 4. 确保认证令牌在AuthService和GameService之间共享
 */
GameService::GameService(ApiClient *apiClient, QObject *parent)
    : QObject(parent)
    , m_apiClient(apiClient)  // 使用共享的API客户端
    , m_serviceDiscovery(new GameServiceDiscovery(Config::getApiBaseUrl(), this))  // 创建服务发现客户端
{
    // === 建立传统API信号槽连接 ===
    connect(m_apiClient, &ApiClient::requestFinished,
            this, &GameService::onApiResponse);
    
    // === 建立服务发现信号槽连接 ===
    connect(m_serviceDiscovery, &GameServiceDiscovery::servicesReceived,
            this, &GameService::onServicesDiscovered);
    connect(m_serviceDiscovery, &GameServiceDiscovery::errorOccurred,
            this, &GameService::onServiceDiscoveryError);
    connect(m_serviceDiscovery, &GameServiceDiscovery::networkError,
            this, [this](const QString &error) {
                emit serviceDiscoveryError(error, "NETWORK_ERROR");
            });
}

/**
 * @brief 获取游戏服务器列表
 * @param gameType 游戏类型筛选（可选：snake、tetris、puzzle等）
 * @param region 地区筛选（可选：asia、europe、america等）
 * @param status 状态筛选（默认：online，可选：offline、maintenance等）
 * @param sortBy 排序方式（可选：ping、players、load等）
 * @param limit 每页数量限制（默认：50）
 * @param offset 分页偏移量（默认：0）
 *
 * 向API Gateway请求游戏服务器列表，支持多种筛选和排序选项。
 * 根据后端API文档，使用不同的端点获取不同游戏类型的服务器列表。
 */
void GameService::getGameServers(const QString &gameType, const QString &region,
                                const QString &status, const QString &sortBy,
                                int limit, int offset)
{
    // === 设置待处理操作标识 ===
    m_pendingOperation = "getGameServers";

    // === 根据游戏类型选择API端点 ===
    QString endpoint;
    QJsonObject params;

    if (gameType.toLower() == "snake") {
        // Snake游戏使用公开API端点获取房间列表（根据后端API文档）
        endpoint = "/api/v1/snake/rooms/public";

        // Snake游戏公开房间列表的查询参数（根据SNAKE_GAME_SERVICE_API.md）
        if (limit > 0) params["limit"] = limit;
        if (offset > 0) params["page"] = (offset / limit) + 1;  // 转换为页码
        if (!status.isEmpty() && status != "online") params["status"] = status;

    } else {
        // 其他游戏类型使用通用认证端点获取服务器列表
        endpoint = "/api/v1/game/servers";

        // === 构建查询参数 ===
        /* 查询参数构建示例：
         * 输入参数：
         * gameType = "tetris"
         * region = "asia"
         * status = "online"
         * sortBy = "ping"
         * limit = 20
         * offset = 0
         *
         * 构建的JSON对象：
         * {
         *   "game_type": "tetris",
         *   "region": "asia",
         *   "status": "online",
         *   "sort_by": "ping",
         *   "limit": 20,
         *   "offset": 0
         * }
         */

        // === 可选参数处理 ===
        // 只有非空参数才会被添加到查询中
        if (!gameType.isEmpty()) params["game_type"] = gameType;    // 游戏类型筛选
        if (!region.isEmpty()) params["region"] = region;           // 地区筛选
        if (!status.isEmpty()) params["status"] = status;           // 状态筛选
        if (!sortBy.isEmpty()) params["sort_by"] = sortBy;          // 排序方式
        if (limit > 0) params["limit"] = limit;                     // 分页大小
        if (offset > 0) params["offset"] = offset;                  // 分页偏移
    }

    // === 发送GET请求 ===
    qDebug() << "GameService: Requesting servers from endpoint:" << endpoint;
    qDebug() << "GameService: Query parameters:" << params;
    m_apiClient->get(endpoint, params);
}

/**
 * @brief 加入游戏会话
 * @param gameType 游戏类型（snake、tetris、puzzle等）
 * @param serverPreference 服务器偏好（auto、low_ping、low_load等）
 *
 * 向服务器请求加入指定类型的游戏，服务器会分配最合适的游戏服务器。
 */
void GameService::joinGame(const QString &gameType, const QString &serverPreference)
{

    // === 设置待处理操作标识 ===
    m_pendingOperation = "joinGame";

    // === 使用统一的游戏认证端点 ===
    // 根据API文档，所有游戏类型都使用 /api/v1/game/login 端点（通过Gateway路由到Auth Service）
    QString endpoint = "/api/v1/game/login";
    QJsonObject data;

    // === 构建游戏认证请求数据 ===
    /* 根据API文档的游戏认证请求格式：
     * POST /api/v1/game/login
     * Authorization: Bearer <access_token>
     * {
     *   "game_type": "snake",
     *   "preferred_server_region": "asia-east",
     *   "metadata": {
     *     "client_version": "1.2.3",
     *     "platform": "web"
     *   }
     * }
     */
    data["game_type"] = gameType;                               // 游戏类型
    data["preferred_server_region"] = Config::getSnakeGameDefaultRegion(); // 首选地区
    data["client_ip"] = "127.0.0.1";                          // 客户端IP（实际应用中应获取真实IP）
    data["user_agent"] = QString("Qt6GameClient/%1").arg(Config::getAppVersion()); // 用户代理

    // 如果有特定的服务器偏好，可以添加到metadata中
    if (!serverPreference.isEmpty()) {
        QJsonObject metadata;
        metadata["server_preference"] = serverPreference;
        metadata["client_version"] = Config::getAppVersion();
        metadata["platform"] = "Qt6";
        metadata["client_type"] = "qt6_game_client";
        metadata["capabilities"] = QJsonArray{"websocket", "real_time", "multiplayer"};
        data["metadata"] = metadata;
    }

    // 为Snake游戏添加特殊配置
    if (gameType.toLower() == "snake") {
        QJsonObject snakeConfig;
        snakeConfig["protocol_version"] = "1.0";
        snakeConfig["supported_protocols"] = QJsonArray{"qt6-optimized", "snake-game-v1"};
        snakeConfig["features"] = QJsonArray{"chat", "spectate", "reconnect"};
        data["snake_config"] = snakeConfig;
    }

    qDebug() << "GameService: Authenticating for game:" << gameType;
    qDebug() << "GameService: Using endpoint:" << endpoint;
    qDebug() << "GameService: Request data:" << data;

    // === 发送游戏认证请求 ===
    m_apiClient->post(endpoint, data);
}

void GameService::getBestServers(const QString &gameType, const QString &region, int limit)
{
    getGameServers(gameType, region, "online", "ping", limit, 0);
}

/**
 * @brief API响应处理槽函数
 * @param endpoint 请求的API端点
 * @param response API服务器的响应数据
 *
 * 根据不同的操作类型处理API响应，解析JSON数据并发出相应信号。
 */
void GameService::onApiResponse(const QString &endpoint, const ApiClient::ApiResponse &response)
{
    // === 处理获取游戏服务器列表响应 ===
    if (m_pendingOperation == "getGameServers") {
        if (response.success) {
            /* 服务器列表响应示例：
             * {
             *   "success": true,
             *   "data": {
             *     "servers": [
             *       {
             *         "server_id": "snake-asia-01",
             *         "name": "Snake Asia Server 1",
             *         "host": "snake-asia-01.gameserver.com",
             *         "port": 8080,
             *         "game_type": "snake",
             *         "region": "asia",
             *         "status": "online",
             *         "max_players": 100,
             *         "current_players": 45,
             *         "ping": 25,
             *         "load_percentage": 45.0,
             *         "version": "1.2.3",
             *         "features": ["ranked", "casual"],
             *         "last_updated": "2024-01-01T12:00:00Z"
             *       }
             *     ],
             *     "summary": {
             *       "total_servers": 150,
             *       "online_servers": 120,
             *       "maintenance_servers": 5,
             *       "total_players": 2500,
             *       "total_capacity": 15000
             *     },
             *     "pagination": {
             *       "total": 150,
             *       "page": 1,
             *       "pages": 3,
             *       "limit": 50
             *     }
             *   }
             * }
             */

            // === 解析服务器列表 ===
            QJsonArray serversArray;
            QList<GameServer> servers;

            // 根据不同的API响应格式解析服务器列表
            if (endpoint.contains("/snake/rooms/public")) {
                // Snake游戏公开房间列表API（根据SNAKE_GAME_SERVICE_API.md）
                serversArray = response.data["rooms"].toArray();
            } else if (response.data.contains("servers")) {
                // 通用游戏服务器API格式（根据AUTH_SERVICE_API.md）
                serversArray = response.data["servers"].toArray();
            } else {
                // 如果没有找到预期的结构，使用空数组
                qWarning() << "GameService: Unexpected response format, using empty servers array";
                qWarning() << "GameService: Response data keys:" << response.data.keys();
                serversArray = QJsonArray();
            }

            // 遍历服务器数组，将每个JSON对象转换为GameServer结构体
            for (const QJsonValue &value : serversArray) {
                GameServer server = parseGameServer(value.toObject());
                // 为Snake游戏服务器设置默认值
                if (server.gameType.isEmpty()) {
                    server.gameType = "snake";
                }
                servers.append(server);
            }

            qDebug() << "GameService: Parsed" << servers.size() << "servers";

            // === 解析汇总统计信息 ===
            ServerSummary summary;
            if (endpoint.contains("/snake/rooms/public")) {
                // Snake游戏公开房间列表API统计信息（根据SNAKE_GAME_SERVICE_API.md）
                if (response.data.contains("statistics")) {
                    QJsonObject stats = response.data["statistics"].toObject();
                    summary.totalServers = stats["total_public_rooms"].toInt();
                    summary.onlineServers = stats["waiting_rooms"].toInt() + stats["playing_rooms"].toInt();
                    summary.totalPlayers = stats["total_players_online"].toInt();
                    summary.totalCapacity = summary.totalServers * 8; // 假设每个房间最多8人
                }
            } else if (response.data.contains("summary")) {
                // 通用游戏服务器API汇总信息
                summary = parseServerSummary(response.data["summary"].toObject());
            }

            // === 解析分页信息 ===
            if (endpoint.contains("/snake/rooms/public")) {
                // Snake游戏公开房间列表API分页信息（根据SNAKE_GAME_SERVICE_API.md）
                if (response.data.contains("pagination")) {
                    QJsonObject pagination = response.data["pagination"].toObject();
                    summary.totalServers = pagination["total_count"].toInt();
                    summary.currentPage = pagination["page"].toInt();
                    summary.totalPages = pagination["total_pages"].toInt();
                    summary.pageSize = pagination["limit"].toInt();
                }
            } else if (response.data.contains("pagination")) {
                // 通用游戏服务器API分页信息
                QJsonObject pagination = response.data["pagination"].toObject();
                summary.totalServers = pagination["total"].toInt();
                summary.currentPage = pagination["page"].toInt();
                summary.totalPages = pagination["pages"].toInt();
                summary.pageSize = pagination["limit"].toInt();
            }

            // === 发出成功信号 ===
            emit gameServersReceived(servers, summary);
        } else {
            // === 处理错误响应 ===
            emit requestFailed(response.errorMessage);
        }
    }
    // === 处理游戏加入响应 ===
    else if (m_pendingOperation == "joinGame") {
        if (response.success) {
            // === 添加调试信息，查看实际的服务器响应 ===
            qDebug() << "GameService: 收到游戏加入成功响应";
            qDebug() << "GameService: 响应数据:" << QJsonDocument(response.data).toJson(QJsonDocument::Compact);

            /* 游戏加入成功响应示例：
             * {
             *   "success": true,
             *   "data": {
             *     "game_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
             *     "player_id": "player_12345",
             *     "session_id": "session_67890",
             *     "websocket_url": "ws://127.0.0.1:8085",
             *     "server_info": {
             *       "server_id": "snake_game_127.0.0.1_8084_1703123456789",
             *       "host": "127.0.0.1",
             *       "websocket_port": 8085,
             *       "region": "local"
             *     },
             *     "player_profile": {
             *       "username": "player123",
             *       "level": 5,
             *       "total_score": 15420,
             *       "games_played": 89
             *     },
             *     "expires_at": 1703127056789
             *   }
             * }
             */
            GameLoginResult result = parseGameLoginResult(response.data);
            
            // 为Snake游戏添加特殊处理
            if (result.serverInfo.gameType.toLower() == "snake") {
                // 确保WebSocket URL正确设置
                if (result.gameConfig.contains("websocket_url")) {
                    QString wsUrl = result.gameConfig["websocket_url"].toString();
                    if (!wsUrl.isEmpty()) {
                        qDebug() << "GameService: Snake WebSocket URL:" << wsUrl;
                    }
                }
                
                // 添加Snake游戏特定的配置
                if (!result.gameConfig.contains("game_mode")) {
                    result.gameConfig["game_mode"] = 1; // 默认经典模式
                }
                if (!result.gameConfig.contains("max_players")) {
                    result.gameConfig["max_players"] = 4; // 默认最大4人
                }
            }
            
            emit gameJoinSucceeded(result);
        } else {
            /* 游戏加入失败响应示例：
             * {
             *   "success": false,
             *   "error_message": "服务器已满，请稍后重试",
             *   "error_code": "SERVER_FULL"
             * }
             */
            emit gameJoinFailed(response.errorMessage);
        }
    }

    // === 清除操作标识 ===
    m_pendingOperation.clear();
}

/**
 * @brief 解析游戏服务器JSON对象
 * @param data 包含服务器信息的JSON对象
 * @return 解析后的GameServer结构体
 *
 * 将从API响应中获取的JSON服务器信息转换为GameServer结构体。
 */
GameService::GameServer GameService::parseGameServer(const QJsonObject &data) const
{
    /* JSON到GameServer的解析过程：
     * 输入JSON对象示例：
     * {
     *   "server_id": "snake-asia-01",
     *   "name": "Snake Asia Server 1",
     *   "host": "snake-asia-01.gameserver.com",
     *   "port": 8080,
     *   "game_type": "snake",
     *   "region": "asia",
     *   "status": "online",
     *   "max_players": 100,
     *   "current_players": 45,
     *   "ping": 25,
     *   "load_percentage": 45.0,
     *   "version": "1.2.3",
     *   "features": ["ranked", "casual", "tournament"],
     *   "last_updated": "2024-01-01T12:00:00Z"
     * }
     */
    GameServer server;

    // === 基本服务器信息字段解析 ===
    // 支持多种字段名格式，适配不同的API响应
    
    // Snake游戏房间格式（根据SNAKE_GAME_SERVICE_API.md）
    if (data.contains("room_id")) {
        server.serverId = data["room_id"].toString();
        server.name = data["room_name"].toString();
        server.gameType = "snake";
        server.status = data["status"].toString();
        server.maxPlayers = data["max_players"].toInt();
        server.currentPlayers = data["current_players"].toInt();
        // Snake游戏房间没有直接的host/port，需要从其他途径获取
        server.host = "localhost";  // 默认值，实际应从游戏认证获取
        server.port = 8084;         // Snake游戏服务端口
        server.region = "default";
    } else {
        // 通用游戏服务器格式（根据AUTH_SERVICE_API.md）
        server.serverId = data["server_id"].toString();
        if (server.serverId.isEmpty()) {
            server.serverId = data["id"].toString();
        }

        server.name = data["name"].toString();
        if (server.name.isEmpty()) {
            server.name = data["server_name"].toString();
        }

        server.host = data["host"].toString();
        if (server.host.isEmpty()) {
            server.host = data["hostname"].toString();
        }

        server.port = data["port"].toInt();
        // 不要用websocket_port覆盖HTTP端口，它们是不同的端口
        // websocket_port将在后续单独处理

        server.gameType = data["game_type"].toString();
        if (server.gameType.isEmpty()) {
            server.gameType = data["type"].toString();
        }

        server.region = data["region"].toString();
        server.status = data["status"].toString();

        server.maxPlayers = data["max_players"].toInt();
        if (server.maxPlayers == 0) {
            server.maxPlayers = data["capacity"].toInt();
        }

        server.currentPlayers = data["current_players"].toInt();
        if (server.currentPlayers == 0) {
            server.currentPlayers = data["player_count"].toInt();
        }
    }

    server.ping = data["ping"].toInt();
    if (server.ping == 0) {
        server.ping = data["latency"].toInt(); // 备用字段名
    }

    server.loadPercentage = data["load_percentage"].toDouble();
    if (server.loadPercentage == 0.0) {
        server.loadPercentage = data["load"].toDouble(); // 备用字段名
    }

    server.version = data["version"].toString();
    server.lastUpdated = data["last_updated"].toString();
    if (server.lastUpdated.isEmpty()) {
        server.lastUpdated = data["updated_at"].toString(); // 备用字段名
    }

    // === 特性列表解析 ===
    /* 特性数组解析过程：
     * JSON数组：["ranked", "casual", "tournament"]
     * 解析结果：QStringList{"ranked", "casual", "tournament"}
     */
    QJsonArray featuresArray = data["features"].toArray();
    if (featuresArray.isEmpty()) {
        featuresArray = data["game_modes"].toArray(); // Snake API可能使用game_modes
    }

    for (const QJsonValue &value : featuresArray) {
        server.features.append(value.toString());
    }

    // 为Snake游戏服务器设置默认特性
    if (server.features.isEmpty() && server.gameType == "snake") {
        server.features << "multiplayer" << "realtime";
    }

    return server;
}

/**
 * @brief 解析游戏登录结果JSON对象
 * @param data 包含游戏登录结果的JSON对象
 * @return 解析后的GameLoginResult结构体
 *
 * 将游戏加入成功后服务器返回的JSON数据转换为GameLoginResult结构体。
 */
GameService::GameLoginResult GameService::parseGameLoginResult(const QJsonObject &data) const
{
    /* JSON到GameLoginResult的解析过程：
     * 输入JSON对象示例：
     * {
     *   "game_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
     *   "player_id": "player_12345",
     *   "session_id": "session_67890",
     *   "websocket_url": "ws://127.0.0.1:8085",
     *   "server_info": {
     *     "server_id": "snake_game_127.0.0.1_8084_1703123456789",
     *     "host": "127.0.0.1",
     *     "websocket_port": 8085,
     *     "region": "local"
     *   },
     *   "player_profile": {
     *     "username": "player123",
     *     "level": 5,
     *     "total_score": 15420,
     *     "games_played": 89
     *   },
     *   "expires_at": 1703127056789
     * }
     *
     * 解析过程：
     * 1. server_info：嵌套JSON对象，通过parseGameServer()解析
     * 2. game_token：游戏会话令牌字符串
     * 3. session_id：会话ID字符串
     * 4. websocket_url：WebSocket连接地址
     * 5. player_profile：玩家信息JSON对象（保持原始格式）
     * 6. expires_at：会话过期时间（毫秒时间戳）
     */
    GameLoginResult result;

    // === 解析分配的服务器信息 ===
    if (data.contains("game_server")) {
        // 根据AUTH_SERVICE_API.md中game/login响应格式
        result.serverInfo = parseGameServer(data["game_server"].toObject());
    } else if (data.contains("server_info")) {
        // 备用字段名
        result.serverInfo = parseGameServer(data["server_info"].toObject());
    } else {
        // === 如果没有服务器信息，创建默认配置 ===
        qDebug() << "GameService: 响应中没有服务器信息，使用默认配置";
        result.serverInfo.serverId = "default_snake_server";
        result.serverInfo.host = "127.0.0.1";  // 根据API文档使用127.0.0.1
        result.serverInfo.port = 8084;         // HTTP端口（不是WebSocket端口！）
        result.serverInfo.gameType = "snake";
        result.serverInfo.region = "local";
        result.serverInfo.status = "active";

        // 设置默认的WebSocket配置
        result.gameConfig["websocket_port"] = 8085;
        result.gameConfig["websocket_url"] = "ws://127.0.0.1:8085";

        // 如果响应中有websocket_url，尝试从中提取服务器信息
        if (data.contains("websocket_url")) {
            QString wsUrl = data["websocket_url"].toString();
            qDebug() << "GameService: 从websocket_url提取服务器信息:" << wsUrl;

            // 解析WebSocket URL: ws://host:port/path
            QUrl url(wsUrl);
            if (url.isValid()) {
                result.serverInfo.host = url.host();
                result.serverInfo.port = url.port(8085);  // 默认8085（根据API文档）
                qDebug() << "GameService: 提取的服务器信息 - host:" << result.serverInfo.host << "port:" << result.serverInfo.port;
            }
        }
    }

    // === 解析会话信息 ===
    result.sessionToken = data["session_token"].toString();      // 根据实际服务器响应使用session_token
    if (result.sessionToken.isEmpty()) {
        result.sessionToken = data["game_session_token"].toString();  // 备用字段名
    }
    if (result.sessionToken.isEmpty()) {
        result.sessionToken = data["game_token"].toString();      // 第二备用字段名
    }
    
    result.sessionId = data["session_id"].toString();
    result.expiresIn = data["expires_in"].toInt();

    // === 解析玩家信息 ===
    if (data.contains("player_info")) {
        QJsonObject playerInfo = data["player_info"].toObject();
        result.gameConfig["player_id"] = playerInfo["player_id"].toString();
        result.gameConfig["nickname"] = playerInfo["nickname"].toString();
        result.gameConfig["user_id"] = playerInfo["user_id"].toString();
    } else {
        // 如果没有player_info，设置默认值
        qDebug() << "GameService: 响应中没有player_info，设置默认值";
        result.gameConfig["player_id"] = "";
        result.gameConfig["nickname"] = "";
        result.gameConfig["user_id"] = "";
    }

    // === 解析WebSocket URL和游戏数据 ===
    if (data.contains("game_data")) {
        QJsonObject gameData = data["game_data"].toObject();
        // 不要覆盖player_id，保持从player_info中获取的值
        // result.gameConfig["player_id"] = gameData["user_id"].toString();  // 注释掉，避免覆盖
        result.gameConfig["user_id"] = gameData["user_id"].toString();  // 使用user_id字段
        result.gameConfig["player_level"] = gameData["level"].toInt();
        result.gameConfig["player_experience"] = gameData["experience"].toInt();
        result.gameConfig["player_coins"] = gameData["coins"].toInt();
        result.gameConfig["total_games"] = gameData["total_games"].toInt();
        result.gameConfig["wins"] = gameData["wins"].toInt();
        result.gameConfig["losses"] = gameData["losses"].toInt();
        result.gameConfig["win_rate"] = gameData["win_rate"].toDouble();
        result.gameConfig["best_score"] = gameData["best_score"].toInt();
    }

    // === 构建WebSocket连接URL ===
    QJsonObject serverInfo;
    if (data.contains("server_info")) {
        serverInfo = data["server_info"].toObject();
    } else if (data.contains("game_server")) {
        serverInfo = data["game_server"].toObject();
    }

    if (!serverInfo.isEmpty()) {
        QString host = serverInfo["host"].toString();
        int httpPort = serverInfo["port"].toInt();
        int websocketPort = serverInfo["websocket_port"].toInt();

        // 优先使用服务器明确提供的WebSocket端口
        if (websocketPort > 0) {
            QString websocketUrl = QString("ws://%1:%2").arg(host).arg(websocketPort);
            result.gameConfig["websocket_url"] = websocketUrl;
            result.gameConfig["websocket_port"] = websocketPort;
            qDebug() << "GameService: 使用服务器提供的WebSocket端口:" << websocketPort;
        } else if (!host.isEmpty() && httpPort > 0) {
            // 如果没有websocket_port，使用HTTP端口+1的默认规则
            int defaultWebSocketPort = (httpPort == 8084) ? 8085 : httpPort + 1;
            QString websocketUrl = QString("ws://%1:%2").arg(host).arg(defaultWebSocketPort);
            result.gameConfig["websocket_url"] = websocketUrl;
            result.gameConfig["websocket_port"] = defaultWebSocketPort;
            qDebug() << "GameService: 使用计算的WebSocket端口:" << defaultWebSocketPort;
        }
    }

    // === 解析过期时间 ===
    if (data.contains("expires_at")) {
        qint64 expiresAt = data["expires_at"].toVariant().toLongLong();
        qint64 currentTime = QDateTime::currentMSecsSinceEpoch();
        result.expiresIn = static_cast<int>((expiresAt - currentTime) / 1000);
    }

    // === 保存游戏配置 ===
    /* 游戏配置保持JSON格式，便于后续处理：
     * {
     *   "websocket_url": "ws://127.0.0.1:8085",
     *   "player_id": "player_12345",
     *   "player_name": "player123",
     *   "player_level": 5,
     *   "total_score": 15420,
     *   "games_played": 89,
     *   "game_mode": 1,
     *   "max_players": 4
     * }
     */

    return result;
}

/**
 * @brief 解析服务器汇总统计JSON对象
 * @param data 包含服务器统计信息的JSON对象
 * @return 解析后的ServerSummary结构体
 *
 * 将服务器列表响应中的汇总统计信息转换为ServerSummary结构体。
 */
GameService::ServerSummary GameService::parseServerSummary(const QJsonObject &data) const
{
    /* JSON到ServerSummary的解析过程：
     * 输入JSON对象示例：
     * {
     *   "total_servers": 150,
     *   "online_servers": 120,
     *   "maintenance_servers": 5,
     *   "total_players": 2500,
     *   "total_capacity": 15000
     * }
     *
     * 解析过程：
     * 1. 直接从JSON提取各个统计字段
     * 2. 自动转换为对应的整数类型
     * 3. 用于UI显示服务器整体状况
     *
     * 计算示例：
     * - 服务器利用率：120/150 = 80%
     * - 玩家占用率：2500/15000 = 16.7%
     * - 离线服务器：150-120-5 = 25台
     */
    ServerSummary summary;

    // === 服务器数量统计 ===
    summary.totalServers = data["total_servers"].toInt();          // 150（总服务器数）
    summary.onlineServers = data["online_servers"].toInt();        // 120（在线服务器数）
    summary.maintenanceServers = data["maintenance_servers"].toInt(); // 5（维护中服务器数）

    // === 玩家统计 ===
    summary.totalPlayers = data["total_players"].toInt();          // 2500（当前总玩家数）
    summary.totalCapacity = data["total_capacity"].toInt();        // 15000（总容量）

    return summary;
}

// =================== 服务发现API方法实现 ===================

/**
 * @brief 使用服务发现获取游戏服务器列表
 * @param gameType 游戏类型
 * @param healthyOnly 是否只获取健康的服务
 *
 * 推荐使用的服务器发现方法，通过API Gateway的服务发现API获取已注册的游戏服务
 */
void GameService::discoverGameServices(const QString &gameType, bool healthyOnly)
{
    qDebug() << "GameService: 开始服务发现，游戏类型:" << gameType << "仅健康服务:" << healthyOnly;
    
    if (gameType.isEmpty()) {
        m_serviceDiscovery->getAllServices(healthyOnly);
    } else {
        m_serviceDiscovery->getServicesByGameType(gameType, healthyOnly);
    }
}

/**
 * @brief 启用服务发现自动刷新
 * @param interval 刷新间隔（秒）
 */
void GameService::enableServiceDiscoveryAutoRefresh(int interval)
{
    m_serviceDiscovery->setAutoRefreshInterval(interval);
    m_serviceDiscovery->startAutoRefresh();
    qDebug() << "GameService: 启用服务发现自动刷新，间隔" << interval << "秒";
}

/**
 * @brief 禁用服务发现自动刷新
 */
void GameService::disableServiceDiscoveryAutoRefresh()
{
    m_serviceDiscovery->stopAutoRefresh();
    qDebug() << "GameService: 禁用服务发现自动刷新";
}

/**
 * @brief 手动刷新服务发现
 */
void GameService::refreshServiceDiscovery()
{
    m_serviceDiscovery->refreshCurrentQuery();
    qDebug() << "GameService: 手动刷新服务发现";
}

/**
 * @brief 处理服务发现响应
 * @param services 发现的服务列表
 * @param gameType 查询的游戏类型
 * @param queryInfo 查询信息
 */
void GameService::onServicesDiscovered(const QList<GameServiceInfo> &services, const QString &gameType, const QJsonObject &queryInfo)
{
    qDebug() << "GameService: 服务发现完成，发现" << services.size() << "个服务";
    
    // 直接转发服务发现信号
    emit gameServicesDiscovered(services, gameType, queryInfo);
    
    // 同时转换为传统格式并发出兼容信号
    QList<GameServer> gameServers;
    for (const GameServiceInfo &service : services) {
        GameServer server = convertServiceToGameServer(service);
        gameServers.append(server);
    }
    
    ServerSummary summary = generateSummaryFromServices(services);
    emit gameServersReceived(gameServers, summary);
}

/**
 * @brief 处理服务发现错误
 * @param error 错误信息
 * @param errorCode 错误代码
 */
void GameService::onServiceDiscoveryError(const QString &error, const QString &errorCode)
{
    qWarning() << "GameService: 服务发现错误:" << errorCode << error;
    emit serviceDiscoveryError(error, errorCode);
}

/**
 * @brief 将服务发现结果转换为游戏服务器信息
 * @param serviceInfo 服务发现信息
 * @return 游戏服务器信息
 */
GameService::GameServer GameService::convertServiceToGameServer(const GameServiceInfo &serviceInfo) const
{
    GameServer server;
    
    // 基本信息转换
    server.serverId = serviceInfo.uniqueId();
    server.name = serviceInfo.displayName();
    server.host = serviceInfo.host;
    server.port = serviceInfo.port;
    server.gameType = serviceInfo.gameType();
    server.region = serviceInfo.region();
    server.status = serviceInfo.healthy ? "online" : "offline";
    server.maxPlayers = serviceInfo.maxPlayers();
    server.currentPlayers = 0;  // 服务发现不提供当前玩家数
    server.ping = 0;            // 服务发现不提供延迟信息
    server.loadPercentage = 0.0; // 服务发现不提供负载信息
    server.version = serviceInfo.version();
    
    // 从端点列表生成特性
    for (const QString &endpoint : serviceInfo.endpoints) {
        if (endpoint.contains("rooms")) {
            server.features.append("rooms");
        }
        if (endpoint.contains("leaderboard")) {
            server.features.append("leaderboard");
        }
        if (endpoint.contains("ws")) {
            server.features.append("websocket");
        }
    }
    
    server.lastUpdated = serviceInfo.lastHeartbeat;
    
    return server;
}

/**
 * @brief 从服务列表生成汇总信息
 * @param services 服务列表
 * @return 服务器汇总信息
 */
GameService::ServerSummary GameService::generateSummaryFromServices(const QList<GameServiceInfo> &services) const
{
    ServerSummary summary;
    
    summary.totalServers = services.size();
    summary.onlineServers = 0;
    summary.maintenanceServers = 0;
    summary.totalPlayers = 0;
    summary.totalCapacity = 0;
    
    for (const GameServiceInfo &service : services) {
        if (service.healthy) {
            summary.onlineServers++;
        } else {
            summary.maintenanceServers++;
        }
        
        // 估算容量（如果有maxPlayers信息）
        int maxPlayers = service.maxPlayers();
        if (maxPlayers > 0) {
            summary.totalCapacity += maxPlayers;
        }
    }
    
    // 分页信息（服务发现API通常不分页）
    summary.currentPage = 1;
    summary.totalPages = 1;
    summary.pageSize = summary.totalServers;
    
    return summary;
}
